var express = require('express');
var router = express.Router();

const pro = require("../sql/pro")
const sql = require("../sql/sql")


/**
* @apiGroup 商品信息
* @api {get} /api/pro 获取商品数据
* @apiVersion 0.0.0
* @apiDescription 获取所有商品数据
* @apiSuccess {number} code 请求状态
* @apiSuccess {string} msg 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
res.send({
    code:1,
    msg:"请求成功",
    data:[{},{},{},....]
})
* @apiError {number} code 请求状态
* @apiError {string} msg 请求说明
* @apiError {object} data 请求数据
* @apiErrorExample {json} Error-Response:
res.send({
    code:0,
    msg:"请求失败",
    data:错误对象
})
* @apiSampleRequest http://localhost:3000/api/pro
*/

// 请求所有商品数据的接口功能
router.get('/', function(req, res, next) {
    sql.get(pro).then(data=>{
        // 返回给前端
        res.send({
            code:1,
            msg:"请求成功",
            data
        })
    }).catch(err=>{
        res.send({
            code:0,
            msg:"请求失败",
            data:err
        })
    })
});

/**
* @apiGroup 商品信息
* @api {get} /api/pro/detail 获取商品详情数据
* @apiVersion 0.0.0
* @apiDescription 根据商品id，获取商品详情数据
* @apiParam {String} id 商品id
* @apiSuccess {number} code 请求状态
* @apiSuccess {string} msg 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
res.send({
    code:1,
    msg:"请求成功",
    data:[{},{},{},....]
})
* @apiError {number} code 请求状态
* @apiError {string} msg 请求说明
* @apiError {object} data 请求数据
* @apiErrorExample {json} Error-Response:
res.send({
    code:0,
    msg:"请求失败",
    data:错误对象
})
* @apiSampleRequest http://localhost:3000/api/pro/detail
*/

// 获取商品详情
router.get('/detail', function(req, res, next) {
    let id = req.query.id
    sql.get(pro, {proId: id}).then(data=>{
        res.send({
            code:1,
            msg:"获取成功",
            data:data[0]
        })
    }).catch(err=>{
        res.send({
            code:0,
            msg:"获取失败",
            data:err
        })
    })
});


/**
* @apiGroup 商品信息
* @api {get} /api/pro/page 获取分页商品数据
* @apiVersion 0.0.0
* @apiDescription 根据页码和单页条数，获取指定分页商品数据
* @apiParam {Number} index 页码，从0开始
* @apiParam {Number} num 单页条数
* @apiSuccess {number} code 请求状态
* @apiSuccess {string} msg 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
res.send({
    code:1,
    msg:"请求成功",
    data:[{},{},{},....]
})
* @apiError {number} code 请求状态
* @apiError {string} msg 请求说明
* @apiError {object} data 请求数据
* @apiErrorExample {json} Error-Response:
res.send({
    code:0,
    msg:"请求失败",
    data:错误对象
})
* @apiSampleRequest http://localhost:3000/api/pro/page
*/

// 获取分页商品的接口
router.get('/page', function(req, res, next) {
    let index = Number(req.query.index);
    let num = Number(req.query.num);
    sql.getPage(pro, index, num).then(data=>{
        res.send({
            code:1,
            msg:"获取成功",
            data:data
        })
    }).catch(err=>{
        res.send({
            code:0,
            msg:"获取失败",
            data:err
        })
    })
});


/**
* @apiGroup 商品信息
* @api {get} /api/pro/search 模糊查询商品名称
* @apiVersion 0.0.0
* @apiDescription 根据指定关键字，模糊查询商品名称数据
* @apiParam {String} s 要查询的关键字
* @apiSuccess {number} code 请求状态
* @apiSuccess {string} msg 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
res.send({
    code:1,
    msg:"请求成功",
    data:[{},{},{},....]
})
* @apiError {number} code 请求状态
* @apiError {string} msg 请求说明
* @apiError {object} data 请求数据
* @apiErrorExample {json} Error-Response:
res.send({
    code:0,
    msg:"请求失败",
    data:错误对象
})
* @apiSampleRequest http://localhost:3000/api/pro/search
*/

// 模糊查询商品名称的接口
router.get('/search', function(req, res, next) {
    let sType = req.query.s;
    let sBrand = req.query.brand;

    // sBrand，有，意味着sType表示分类，sBrand表示品牌，要搜索分类下的品牌
    // sBrand，没有，意味着sType表示要模糊搜索的名称，要搜索名称

    if(sBrand){
        sql.get(pro, {type: sType, brand: sBrand}).then(data=>{
            res.send({
                code:1,
                msg:"获取成功",
                data:data
            })
        }).catch(err=>{
            res.send({
                code:0,
                msg:"获取失败",
                data:err
            })
        })
    }else{
        sql.get(pro, {proName: new RegExp(sType)}).then(data=>{
            res.send({
                code:1,
                msg:"获取成功",
                data:data
            })
        }).catch(err=>{
            res.send({
                code:0,
                msg:"获取失败",
                data:err
            })
        })
    }
});



/**
* @apiGroup 商品信息
* @api {get} /api/pro/sort 排序数据
* @apiVersion 0.0.0
* @apiDescription 根据指定排序规则，获取排序商品数据
* @apiParam {String} price 默认以价格排序，1升序，-1降序
* @apiSuccess {number} code 请求状态
* @apiSuccess {string} msg 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
res.send({
    code:1,
    msg:"请求成功",
    data:[{},{},{},....]
})
* @apiError {number} code 请求状态
* @apiError {string} msg 请求说明
* @apiError {object} data 请求数据
* @apiErrorExample {json} Error-Response:
res.send({
    code:0,
    msg:"请求失败",
    data:错误对象
})
* @apiSampleRequest http://localhost:3000/api/pro/sort
*/

// 根据指定排序规则，获取排序商品的接口
router.get('/sort', function(req, res, next) {
    // /sort?price=1
    let sortObj = req.query;
    sql.getSort(pro, sortObj).then(data=>{
        res.send({
            code:1,
            msg:"获取成功",
            data:data
        })
    }).catch(err=>{
        res.send({
            code:0,
            msg:"获取失败",
            data:err
        })
    })
});



/**
* @apiGroup 商品信息
* @api {get} /api/pro/kind 根据指定字段，获取分类数据
* @apiVersion 0.0.0
* @apiDescription 根据指定字段，获取分类数据
* @apiParam {String} column 指定分类的字段
* @apiSuccess {number} code 请求状态
* @apiSuccess {string} msg 请求说明
* @apiSuccess {array} data 请求数据
* @apiSuccessExample {json} Success-Response:
res.send({
    code:1,
    msg:"请求成功",
    data:[{},{},{},....]
})
* @apiError {number} code 请求状态
* @apiError {string} msg 请求说明
* @apiError {object} data 请求数据
* @apiErrorExample {json} Error-Response:
res.send({
    code:0,
    msg:"请求失败",
    data:错误对象
})
* @apiSampleRequest http://localhost:3000/api/pro/kind
*/

// 根据指定字段，获取分类数据
router.get('/kind', function(req, res, next) {
    let column = req.query.column;

    sql.getKind(pro, column).then(data=>{
        res.send({
            code:1,
            msg:"获取成功",
            data:data
        })
    }).catch(err=>{
        res.send({
            code:0,
            msg:"获取失败",
            data:err
        })
    })
});



// 根据指定字段，获取分类数据
router.get('/brand', function(req, res, next) {
    let type = req.query.type;

    // 根据 type:手机 查询商品
    // 获取 brand 后 去重

    sql.get(pro, {type}).then(data=>{
        const s = new Set()
        data.forEach(val=>{
            s.add(val.brand)
        })
        res.send({
            code:1,
            msg:"获取成功",
            data:[...s]
        })
    }).catch(err=>{
        res.send({
            code:0,
            msg:"获取失败",
            data:err
        })
    })
});

module.exports = router;
